// #include <iostream>
// class Animal
// {
// public:
//     Animal()
//     {}
//     Animal(const Animal& another)
//     {

//     }
//     ~Animal()
//     {}
//     Animal& operator=(const Animal& another)
//     {
//         if(this != &another)
//         {
//             /**
//              *
//              *
//             */
//         }
//         return *this;
//     }
// };
// int main()
// {
//     std::cout << "hello world" << std::endl;
//     return 0;
// }
// #include <iostream>
// int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
//                    void *(*start_routine)(void *), void *arg)
// {
// }
// void pthread_exit(void *retval)
// {
// }
// int pthread_join(pthread_t thread, void **retval)
// {
// }
// #include <iostream>
// #include <pthread.h>
// pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
// int pthread_mutex_destroy(pthread_mutex_t *mutex)
// {}
// int pthread_mutex_lock(pthread_mutex_t *mutex)
// {}
// int pthread_mutex_unlock(pthread_mutex_t *mutex)
// {}
// int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr)
// {}
// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 创建全局锁，并初始化
// struct cond
// {
//     int _flag;  //是否有资源
//     queue tcb_queue; // 线程队列

//     /*
//     其他属性
//     */
// };
// using task_struct=int;
// struct sem
// {
//     int _count;
//     task_struct *wait_queue;
//     // ...
// // };
// #include <iostream>
// #include <pthread.h>
// #include <semaphore.h>
// int sem_init(sem_t *sem, int pshared, unsigned int value)
// {}
// int sem_destroy(sem_t *sem)
// {}
// int main()
// {
//     pthread_mutex_t mutex; // 创建一把局部锁
//     pthread_mutex_init(&mutex, nullptr); // 初始化
//     return 0;
// }
#include <iostream>
// template <typename T>
// class Singleton
// {
// private:
//     static T data;
// public:
//     static T *GetInstance()
//     {
//         return &data;
//     }
// };
// 懒汉模式, 线程安全
template <typename T>
class Singleton
{
    volatile static T *inst; // 需要设置 volatile 关键字, 否则可能被编译器优化.
    static std::mutex lock;

public:
    static T *GetInstance()
    {
        if (inst == NULL) // 双重判定空指针, 降低锁冲突的概率(让不是NULL的线程，不去竞争锁), 提高性能.
        {                
            lock.lock(); // 使用互斥锁, 保证多线程情况下也只调用一次 new.
            if (inst == NULL)
            {
                inst = new T();
            }
            lock.unlock();
        }
        return inst;
    }
};
int main()
{
}